{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Data Options\n",
    "\n",
    "For organizing, grouping, and transforming the dataset before visualization, including labels, sorting, and indexing:\n",
    "\n",
    "```{eval-rst}\n",
    ".. plotting-options-table:: Data Options\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "(option-attr_labels)=\n",
    "## `attr_labels`\n",
    "\n",
    "The `attr_labels` option controls whether hvPlot automatically uses xarray object attributes as labels for dimensions in your plots. This feature helps create more descriptive plots by extracting meaningful labels and units from your xarray data's metadata.\n",
    "\n",
    "When set to `True`, hvPlot will look for `long_name` attributes to use as dimension labels and `units` attributes to add unit information. If set to `None` (the default), hvPlot attempts to extract labels without showing warnings if attributes aren't found. Setting it to `False` disables this automatic labeling behavior entirely.\n",
    "\n",
    ":::{note}\n",
    "This option only applies to xarray data objects that contain attributes. It has no effect on pandas DataFrames or other data types.\n",
    ":::"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import hvplot.xarray # noqa\n",
    "\n",
    "ds = hvplot.sampledata.air_temperature(\"xarray\").sel(time='2014-02-25 12:00')\n",
    "print(\"Longitude coordinates:\", ds.coords['lon'].attrs)\n",
    "print(\"Latitude coordinates:\", ds.coords['lat'].attrs)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plot1 = ds.hvplot.image(\n",
    "    title=\"attr_labels=None (default)\",\n",
    "    width=350, height=250,\n",
    ")\n",
    "\n",
    "plot2 = ds.hvplot.image(\n",
    "    attr_labels=False,\n",
    "    title=\"attr_labels=False\",\n",
    "    width=350, height=250\n",
    ")\n",
    "\n",
    "plot1 + plot2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "(option-by)=\n",
    "## `by`\n",
    "\n",
    "The `by` option allows you to group your data based on one or more categorical variables. By specifying a dimension name (or a list of dimension names) with `by`, the plot automatically separates the data into groups, making it easier to compare different subsets in a single visualization. By default, a HoloViews [NdOverlay](inv:holoviews#reference/containers/bokeh/NdOverlay) is returned, overlaying all groups in one plot. However, when you set `subplots=True`, an [NdLayout](inv:holoviews#reference/containers/bokeh/NdLayout) is returned instead, arranging the groups as separate subplots."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import hvplot.pandas  # noqa\n",
    "\n",
    "df = hvplot.sampledata.penguins(\"pandas\")\n",
    "\n",
    "df.hvplot.scatter(x='bill_length_mm', y='bill_depth_mm', by='species')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import hvplot.pandas  # noqa\n",
    "\n",
    "df = hvplot.sampledata.penguins(\"pandas\")\n",
    "\n",
    "df.hvplot.scatter(\n",
    "    x='bill_length_mm', y='bill_depth_mm', by='species',\n",
    "    subplots=True, width=250\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "(option-dynamic)=\n",
    "## `dynamic`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The `dynamic` option controls whether the plot is interactive and updates in response to user actions such as zooming, panning, or widget changes. When set to True (the default), hvPlot returns a [DynamicMap](inv:holoviews#reference/containers/bokeh/DynamicMap) that updates the visualization on the fly, making it ideal for exploratory data analysis or streaming data scenarios. However, if you set `dynamic=False`, all the data is embedded directly into the plot. This static approach might be preferable for smaller datasets, but be cautious with large datasets since embedding a lot of data can impact performance."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import hvplot.pandas  # noqa\n",
    "\n",
    "df = hvplot.sampledata.penguins(\"pandas\")\n",
    "\n",
    "df.hvplot.scatter(\n",
    "    x='bill_length_mm', y='bill_depth_mm', groupby=['island', 'sex'],\n",
    "    height=300, width=400, dynamic=False,\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this example, setting `dynamic=False` produces an interactive plot in the browser. You can engage with the plot’s widgets without needing an active Python session, as all the data is embedded directly in the plot.\n",
    "\n",
    "::: {warning}\n",
    "Using `dynamic=False` with very large datasets may significantly impact performance.\n",
    ":::"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "(option-fields)=\n",
    "## `fields`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The `fields` option lets you rename or transform your dataset’s dimensions before plotting. If your data contains dimension names that aren’t descriptive or need minor adjustments for clarity, you can use `fields` to rename them or apply simple transformations. You can also assign metadata such as custom display labels and units by passing [HoloViews Dimension](inv:holoviews#holoviews.core.dimension) objects as the values in the `fields` dictionary.\n",
    "\n",
    ":::{note}\n",
    "If you need to modify the data values themselves (for example, converting units or applying arithmetic operations), consider using the [`transforms`](option-transforms) option instead.\n",
    ":::"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import hvplot.pandas  # noqa\n",
    "import holoviews as hv\n",
    "\n",
    "df = hvplot.sampledata.penguins(\"pandas\")\n",
    "\n",
    "plot1 = df.hvplot.scatter(\n",
    "    x='bill_length_mm', y='bill_depth_mm',\n",
    "    fields={\n",
    "        'bill_length_mm': 'Bill Length',\n",
    "        'bill_depth_mm': 'Bill Depth'\n",
    "    },\n",
    "    title=\"Simple columns renaming\",\n",
    "    width=350,\n",
    ")\n",
    "\n",
    "plot2 = df.hvplot.scatter(\n",
    "    x='bill_length_mm', y='bill_depth_mm',\n",
    "    fields={\n",
    "        'bill_length_mm': hv.Dimension('bill_length', label='Bill Length', unit='mm'),\n",
    "        'bill_depth_mm': hv.Dimension('bill_depth', label='Bill Depth', unit='mm')\n",
    "    },\n",
    "    title=\"Using Holoviews dimension metadata\",\n",
    "    width=350,\n",
    ")\n",
    "\n",
    "plot1 + plot2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this example, the `fields` dictionary changes the axis labels from the original dimension names to more reader-friendly ones."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "(option-groupby)=\n",
    "## `groupby`\n",
    "\n",
    "The `groupby` option specifies one or more dimensions by which to partition your data into separate groups. This grouping enables the creation of interactive widgets that let users filter or switch between different groups. When `dynamic=True` (the default), each group is rendered interactively as a HoloViews [`DynamicMap`](inv:holoviews#reference/containers/bokeh/DynamicMap), updating on-the-fly; otherwise, with `dynamic=False`, all groups are pre-rendered and returned as a [`HoloMap`](inv:holoviews#reference/containers/bokeh/HoloMap)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import hvplot.pandas  # noqa\n",
    "\n",
    "df = hvplot.sampledata.penguins(\"pandas\")\n",
    "\n",
    "df.hvplot.scatter(\n",
    "    x='bill_length_mm', y='bill_depth_mm', groupby='species',\n",
    "    dynamic=False, width=250\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this example, the plot automatically generates a widget that lets users select among the different species, dynamically updating the plot for the selected group. See [`dynamic`](option-dynamic) for more information.\n",
    "\n",
    ":::{note}\n",
    "While both [`by`](option-by) and `groupby` are used to segment your data based on categorical variables, they serve different purposes. The `by` option creates an overlay (or layout, if `subplots=True`) where all groups are displayed simultaneously, whereas the `groupby` option builds an interactive widget. With `groupby`, each group is rendered as a separate element (using a `DynamicMap` if `dynamic=True` or a `HoloMap` otherwise), allowing users to toggle between groups dynamically.\n",
    ":::"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "(option-group_label)=\n",
    "## `group_label`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The `group_label` option lets you set a custom name for the dimension that distinguishes multiple columns when your data is automatically reshaped from wide to long format.\n",
    "\n",
    "When you plot multiple columns (e.g. multiple y values), hvPlot reshapes the dataset internally to a long format by creating:\n",
    "- a value column (default label: \"value\"), and\n",
    "- a variable column (default label: \"Variable\"), which holds the names of the original columns.\n",
    "\n",
    "The `group_label` keyword allows you to rename this `\"Variable\"` column to something more meaningful in your plot, improving clarity in legends and axis labels."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import hvplot.pandas  # noqa\n",
    "\n",
    "df = hvplot.sampledata.penguins(\"pandas\")\n",
    "\n",
    "df.hvplot.box(\n",
    "    y=['bill_length_mm', 'bill_depth_mm'], group_label='Bill size',\n",
    "    value_label='Measurement (mm)'\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    ":::{seealso}\n",
    "[`value_label`](option-value_label)\n",
    ":::"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "(option-kind)=\n",
    "## `kind`\n",
    "\n",
    "The `kind` option determines the type of plot to generate from your data. By specifying a plot kind (such as ‘line’, ‘scatter’, or ‘bar’), you instruct hvPlot to create a specific visualization. For tabular data, the default is ‘line’, which generates a line plot. However, when working with xarray data, hvPlot automatically infers the most appropriate plot type based on the structure of your dataset. For example, it may default to a ‘hist’ plot for two-dimensional data or ‘rgb’ for image-like data.\n",
    "\n",
    "Changing the `kind` parameter allows you to experiment with different visual representations without altering your underlying data."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Tabular data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "import hvplot.pandas  # noqa\n",
    "\n",
    "df = pd.DataFrame({\n",
    "    'year': [2018, 2019, 2020, 2021],\n",
    "    'sales': [50, 100, 150, 200]\n",
    "})\n",
    "\n",
    "line_plot = df.hvplot(x='year', y='sales', title=\"Default line plot\", width=300)\n",
    "bar_plot = df.hvplot(x='year', y='sales', kind='bar', title=\"Bar plot\", width=300)\n",
    "\n",
    "line_plot + bar_plot"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this example, the first plot uses the default (`kind='line'`), while the second explicitly sets `kind='bar'` to create a bar chart. You can also specify it as an attribute of the `hvplot` class:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df.hvplot.bar(x='year', y='sales')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Xarray data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import hvplot.xarray  # noqa\n",
    "\n",
    "ds = hvplot.sampledata.air_temperature(\"xarray\")\n",
    "\n",
    "hist_plot = ds.hvplot(title=\"Hist plot\", width=300)\n",
    "image_plot = ds.isel(time=0).hvplot.image(title=\"Image plot\", width=300)\n",
    "\n",
    "hist_plot + image_plot"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "(option-label)=\n",
    "## `label`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The `label` option allows to set the `label` attribute on the HoloViews objects that are returned by calls to hvPlot plotting methods. When set, the label usually ends up being displayed as the plot title for simple plots, and in the legend for overlays.\n",
    "\n",
    ":::{note}\n",
    "The plot's title can alternatively be set with the [`title`](option-title) option, which takes precedence over `label` when both options are set. Note that even though the plot looks similar, the object returned wouldn't have its `label` attribute set if the title is declared with the `title` option.\n",
    ":::"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import hvplot.pandas  # noqa\n",
    "\n",
    "df = hvplot.sampledata.penguins(\"pandas\")\n",
    "\n",
    "plot = df.hvplot.scatter(\"bill_depth_mm\", \"bill_length_mm\", width=300, label=\"label set\")\n",
    "print(plot.label)\n",
    "plot"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import hvplot.pandas  # noqa\n",
    "\n",
    "df = hvplot.sampledata.penguins(\"pandas\")\n",
    "\n",
    "plot = df.hvplot.scatter(\n",
    "    \"bill_depth_mm\", \"bill_length_mm\", width=300,\n",
    "    label=\"label set\", title=\"title takes precedence\",\n",
    ")\n",
    "print(plot.label)\n",
    "plot"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Below is a typical of example showing how to use both `label` and `title` to set the legend labels and the plot title. Note `title` can be set in any of the two plotting method calls."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import hvplot.pandas  # noqa\n",
    "import pandas as pd\n",
    "\n",
    "df = pd.DataFrame({\n",
    "    'name': [\"Mark\", \"Luke\", \"Ken\", \"June\"],\n",
    "    'age': [15, 20, 25, 30]\n",
    "})\n",
    "\n",
    "line_plot = df.hvplot.line(x=\"name\", y=\"age\", color=\"red\", label=\"Line plot\")\n",
    "bar_plot = df.hvplot.bar(\n",
    "    x=\"name\", y=\"age\", label=\"Bar plot\",\n",
    "    width=400, title=\"Ages of students\",\n",
    ")\n",
    "bar_plot * line_plot"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "(option-persist)=\n",
    "## `persist`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The `persist` option is useful when working with Dask-backed datasets. Setting `persist=True` tells Dask to compute and keep the data in memory, which can speed up subsequent interactions and visualizations for large or computationally expensive datasets.\n",
    "\n",
    ":::{seealso}\n",
    "[`use_dask`](option-use_dask)\n",
    ":::"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "(option-row)=\n",
    "## `row`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The `row` and [`col`](option-col) options allow you to facet your plot into multiple subplots based on categorical variables. Using `row` arranges the facets vertically, while `col` arranges them horizontally.\n",
    "\n",
    "Faceting makes it easier to compare different subsets of your data side by side within a single visualization."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import hvplot.pandas  # noqa\n",
    "import pandas as pd\n",
    "\n",
    "df = hvplot.sampledata.penguins(\"pandas\")\n",
    "\n",
    "df.hvplot.scatter(x='bill_length_mm', y='bill_depth_mm', row='species', col='island')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this example, the data is split into separate subplots: one row per `species` and one column per `island`, which allows for easy comparison between the different subsets."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "(option-col)=\n",
    "## `col`\n",
    "\n",
    "See [`row`](option-row) above."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "(option-sort_date)=\n",
    "## `sort_date`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The `sort_date` option ensures that the x-axis is sorted chronologically when your data contains date values. This helps to correctly display time series data even if the original dataset isn’t in order. It is set to `True` by default."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import hvplot.pandas  # noqa\n",
    "\n",
    "df = hvplot.sampledata.apple_stocks(\"pandas\")\n",
    "sampled = df.sample(frac=1)\n",
    "print(sampled.head(3))\n",
    "\n",
    "plot1 = sampled.hvplot.line(x='date', y='close', width=300)\n",
    "plot2 = sampled.hvplot(x='date', y='close', sort_date=False, width=300)\n",
    "plot1 + plot2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the first plot, even though the `dates` column in the `sampled` DataFrame are unsorted, the plot’s x-axis will display them in chronological order. However, setting `sort_date=False` results in jumbled lines in the plot because the lines are plotted in the order in which they appear in the dataframe."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "(option-subplots)=\n",
    "## `subplots`\n",
    "\n",
    "The `subplots` option is a boolean flag that, when enabled (set to `True`), displays each group specified by the `by` keyword in its own subplot. This contrasts with the default behavior of overlaying all groups in a single plot, and it can provide clearer side-by-side comparisons of grouped data.\n",
    "\n",
    ":::{note}\n",
    "You can use `subplots=True` together with `.cols(N)` to specify the maximum number of columns to arrange the plots in.\n",
    ":::"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import hvplot.pandas  # noqa\n",
    "\n",
    "df = hvplot.sampledata.penguins(\"pandas\")\n",
    "\n",
    "df.hvplot.scatter(\n",
    "    x='bill_length_mm', y='bill_depth_mm', by='species',\n",
    "    subplots=True, width=300\n",
    ").cols(2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this example, setting `.cols(2)` arranges the plots into two columns.\n",
    "\n",
    "See [`by`](option-by) for more example usage."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "(option-transforms)=\n",
    "## `transforms`\n",
    "\n",
    "The `transforms` option allows you to modify data values for specific dimensions before plotting. Unlike the [`fields`](option-fields) option which only renames or adds metadata, `transforms` applies HoloViews expressions to the data. It accepts a dictionary where each key is a dimension (for example, a DataFrame column name) and each value is a HoloViews expression built with [`holoviews.dim()`](inv:holoviews#holoviews.util.transform.dim) that defines how to transform that dimension.\n",
    "\n",
    "For instance, if you have a 'probability' column with values between 0 and 1 and you want to display them as percentages, you can define a transformation as:\n",
    "\n",
    "`percent = hv.dim('probability') * 100`\n",
    "\n",
    "When passed via the transforms keyword, this expression multiplies all values in the ‘probability’ column by 100 before plotting."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import holoviews as hv\n",
    "import hvplot.pandas  # noqa\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "\n",
    "df = pd.DataFrame({'value': np.random.randn(50), 'probability': np.random.rand(50)})\n",
    "\n",
    "percent = hv.dim('probability') * 100\n",
    "df.hvplot.scatter(\n",
    "    x='value', y='probability', transforms={'probability': percent}\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "(option-use_dask)=\n",
    "## `use_dask`\n",
    "\n",
    "The `use_dask` option enables support for Dask-backed xarray datasets, allowing hvPlot to perform out-of-core and parallelized computations.\n",
    "This is particularly useful for working with large multi-dimensional datasets that don’t fit in memory.\n",
    "\n",
    "If you set `persist=True`, it persists the data in memory for improved performance on subsequent operations."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "(option-use_index)=\n",
    "## `use_index`\n",
    "\n",
    "The `use_index` option determines whether the data’s index is used as the x-axis by default. By default hvPlot automatically assigns the DataFrame’s index as a coordinate for plotting. This is particularly useful when the index contains meaningful information (such as timestamps) and when no explicit x-axis column is specified.\n",
    "\n",
    "If you set `use_index=False`, hvPlot uses the first non-index column as the x-axis."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import hvplot.pandas  # noqa\n",
    "import pandas as pd\n",
    "\n",
    "dates = pd.date_range('2024-01-01', periods=5, freq='D')\n",
    "df = pd.DataFrame({\n",
    "    'open': [100, 102, 101, 103, 105],\n",
    "    'close': [101, 103, 102, 104, 106],\n",
    "}, index=dates)\n",
    "\n",
    "df.hvplot.line(y=['open', 'close'], group_label='Price')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Notice the use of the index column (`dates`) as the x-axis."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "(option-value_label)=\n",
    "## `value_label`\n",
    "\n",
    "The `value_label` option sets a custom label for the data values, and is typically used to label the y-axis or to annotate legends. By default, it is set to 'value', but you can override it with a more descriptive name to better convey what the data represents."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import hvplot.pandas  # noqa\n",
    "\n",
    "df = hvplot.sampledata.penguins(\"pandas\")\n",
    "\n",
    "df.hvplot.box(\n",
    "    y=['bill_length_mm', 'bill_depth_mm'], group_label='Bill size',\n",
    "    value_label='Measurement (mm)'\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    ":::{seealso}\n",
    "[`group_label`](option-group_label)\n",
    ":::"
   ]
  }
 ],
 "metadata": {
  "language_info": {
   "name": "python",
   "pygments_lexer": "ipython3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}
